Strands : An E cient and Extensible Thread Management Architecture

Applications can signi cantly bene t from specializing thread packages, schedulers and synchronization primitives to their needs. In prior systems, specialization has been accomplished through a partitioning of service across the user-kernel boundary. The kernel provides some basic control ow services while user code implements the specialized interface. This approach, though, has been shown to su er from poor performance or poor integration [Anderson et al. 92]. In this paper, we describe a new architecture for thread and scheduling subsystems that provides correct, extensible and e cient thread management for applications. The strand architecture enables applications to place their specialized thread management code in the kernel address space. This allows the operating system to perform upcalls without crossing costly hardware boundaries. As well, it enables applications to contact other system services with low overhead. The system safety issues that arise when placing application code in the kernel are handled in two ways. First, application handlers are written in a typesafe language, Modula-3, to ensure memory-safety. A user thread package executing in the kernel cannot corrupt the kernel's memory or call inappropriate kernel procedures. Second, the strand interface is structured to prohibit the failure of any application handler from a ecting threads not directly managed by that handler. The end result is that the strand architecture allows application code to be tightly integrated with system services, thereby enabling correct, safe and e cient implementations of specialized thread managers. We have implemented the strands architecture in the context of SPIN, which is an extensible operating system being developed at the University of Washington. Using strands, we have implemented several threads packages, including CThreads[Cooper & Draves 88], Mach kernel threads[Accetta et al. 86] and UNIX processes[Ritchie & Thompson 74], as well as low overhead synchronization primitives[Bershad et al. 92], application-speci c schedulers[Zahorjan & McCann